package com.solution.admin.product.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.solution.admin.product.constants.ProductConstants;
import com.solution.admin.product.dao.ProductPropertyTemplateDao;
import com.solution.admin.product.entity.ProductPropertyEntity;
import com.solution.admin.product.entity.ProductPropertyTemplateEntity;
import com.solution.admin.product.entity.ProductSpecEntity;
import com.solution.admin.product.service.ProductPropertyTemplateService;
import com.solution.common.dao.BaseDao;
import com.solution.common.page.PageBean;
import com.solution.common.page.PageParam;
import com.solution.common.service.impl.BaseServiceImpl;
import com.solution.common.utils.string.StringUtil;

/**
 * 商品属性模版service实现层
 * @author lilp
 * @date 2017-09-01 23:36:30
 */
@Service
public class ProductPropertyTemplateServiceImpl extends BaseServiceImpl<ProductPropertyTemplateEntity> implements ProductPropertyTemplateService {

	/**
	 * 商品属性模版接口
	 */
	@Autowired
	private ProductPropertyTemplateDao productPropertyTemplateDao;

	protected BaseDao<ProductPropertyTemplateEntity> getDao() {
		return this.productPropertyTemplateDao;
	}

	/**
	 * 保存商品属性模版
	 * @param productPropertyTemplateEntity 商品属性模版实体
	 * @return Long 添加成功商品属性模版的ID
	 * @author lilp
	 * @date 2017-09-01 23:36:30
	 */
	@Transactional(rollbackFor=Exception.class)
	public long saveProductPropertyTemplate(ProductPropertyTemplateEntity productPropertyTemplateEntity) {
		// 保存模板信息；
		long id = productPropertyTemplateDao.saveProductPropertyTemplate(productPropertyTemplateEntity);
		if (id > 0){
			String propertyIds = productPropertyTemplateEntity.getPropertyIds();
			List<ProductPropertyTemplateEntity> propertyList = new ArrayList<ProductPropertyTemplateEntity>();
			for (String propertyId : propertyIds.split(",")) {
				ProductPropertyTemplateEntity ppte = new ProductPropertyTemplateEntity();
				ppte.setId(id);
				ppte.setPropertyId(Long.parseLong(propertyId));
				ppte.setSortNo(propertyIds.indexOf(propertyId));
				propertyList.add(ppte);
			}
			// 保存模板中商品属性关联记录
			int result = productPropertyTemplateDao.batchInsertProductPropertyForTemplate(propertyList);
		}
		return id;
	}

	/**
	 * 分页查询商品属性模版
	 * @param pageParam 分页参数
	 * @param paramMap 查询参数
	 * @return PageBean 分页参数和分页数据
	 * @author lilp
	 * @date 2017-09-01 23:36:30
	 */
	@Override
	public PageBean listProductPropertyTemplatePage(PageParam pageParam, Map<String, Object> paramMap) {
		return productPropertyTemplateDao.listProductPropertyTemplatePage(pageParam, paramMap);
	}
	
	/**
	 * 根据ID查询用户信息
	 * @param id 用户id
	 * @return productPropertyTemplateEntity 用户对象
	 * @author lilp
	 * @date 2017-09-01 23:36:30
	 */
	public ProductPropertyTemplateEntity getProductPropertyTemplateById(Long id) {
		return productPropertyTemplateDao.getById(id.longValue());
	}

	/**
	 * 更新用户
	 * @param productPropertyTemplateEntity 用户实体
	 * @return Long 更新是否成功，>1代表更新成功
	 * @author lilp
	 * @date 2017-09-01 23:36:30
	 */
	@Override
	@Transactional(rollbackFor=Exception.class)
	public int updateProductPropertyTemplate(ProductPropertyTemplateEntity productPropertyTemplateEntity) {
		// 修改思路：删除模板中已有的属性，重新添加属性到模板中，同时更新模板的基本信息
		// 删除模板中已有属性
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("templateId", productPropertyTemplateEntity.getId());
		
		// 根据propertyIds 查询模块内的属性列表
		List<ProductPropertyTemplateEntity> detailList =  productPropertyTemplateDao.listPropertyTemplateDetail(param); 
		Map<Long, ProductPropertyTemplateEntity> detailMap = new HashMap<Long, ProductPropertyTemplateEntity>();
		if(detailList != null && detailList.size() > 0){
			for (ProductPropertyTemplateEntity detail : detailList) {
				detailMap.put(detail.getPropertyId(), detail);
			}
		}
		int result = 0;
		//int result = productPropertyTemplateDao.deleteProductPropertyFromTemplate(param);		
		// 重新插入或更新已存在的商品属性到模板中
		String propertyIds = productPropertyTemplateEntity.getPropertyIds();
		List<ProductPropertyTemplateEntity> propertyList = new ArrayList<ProductPropertyTemplateEntity>();
		String[] propertyArr = propertyIds.split(",");
		for (int i = 0 ; i < propertyArr.length; i++) {
			String propertyId = propertyArr[i];
			if(detailMap.containsKey(Long.parseLong(propertyId))){
				ProductPropertyTemplateEntity ppte = detailMap.get(Long.parseLong(propertyId));
				ppte.setSortNo(i);
				productPropertyTemplateDao.updateProductPropertyTemplatePropertySort(ppte);
			}else{
				ProductPropertyTemplateEntity ppte = new ProductPropertyTemplateEntity();
				ppte.setId(productPropertyTemplateEntity.getId());
				ppte.setPropertyId(Long.parseLong(propertyId));
				ppte.setSortNo(propertyIds.indexOf(propertyId));
				propertyList.add(ppte);
			}
		}
		if(propertyList != null && propertyList.size() > 0){
			result = productPropertyTemplateDao.batchInsertProductPropertyForTemplate(propertyList);
		}
		// 更新模板基本信息
		return productPropertyTemplateDao.updateProductPropertyTemplate(productPropertyTemplateEntity);
	}
	
	
	/**
	 * 根据条件查询商品属性模版
	 * @param param
	 * @return 数据列表
	 * @author lilp
	 * @date 2017-09-01 23:36:30
	 */
	@Override
	public List<ProductPropertyTemplateEntity> listProductPropertyTemplate( Map<String, Object> param){
		return  productPropertyTemplateDao.listProductPropertyTemplate(param);
	}
	
	/**
	 * 删除商品属性模版
	 * @param 
	 * @return int 返回删除记录条数
	 * @author lilp
	 * @date 2017-09-01 23:36:30
	 */
	@Override
	@Transactional(rollbackFor=Exception.class)
	public int deleteProductPropertyTemplateById(long id){
		// 思路：删除模板中的商品属性，再删除模板本身
		// 删除模板中的商品属性
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("templateId", id);
		productPropertyTemplateDao.deleteProductPropertyFromTemplate(param);
		// 删除模板
		return  productPropertyTemplateDao.deleteById(id);
	}
	
	
	/**
	 * 将商品属性添加到模块中
	 * @param valueOf
	 * @return
	 * @author lilp
	 * @date 2017-09-01 23:36:30
	 */
	@Override
	public int addProductPropertyToTemplate(Map<String, Object>  param){
		return productPropertyTemplateDao.addProductPropertyToTemplate(param);
	}
	
	/**
	 * 将商品属性从模板中移除
	 * @param param
	 * @return
	 * @author lilp
	 * @date 2017-09-01 23:36:30
	 */
	@Override
	public int deleteProductPropertyFromTemplate(Map<String, Object> param){
		return productPropertyTemplateDao.deleteProductPropertyFromTemplate(param);
	}
	
	
	/**
	 * 修改商品模板中商品属性的顺序 
	 * @param templateId
	 * @param id
	 * @param direction
	 * @return
	 */
	@Override
	public int updateProductPropertyTemplatePropertySort(String templateId,
			String id, String direction, int sortNo){
		// 查询离本条记录最近的，最大值排序值和记录；两条记录交换sort_no 字段的值
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("id", id);
		param.put("direction", direction);
		param.put("templateId", templateId);
		param.put("sortNo", sortNo);
		// ppeList 中返回两条记录，第1条待排序记录； 第2条 sort_no小于第1条记录的最近一条记录
		List<ProductPropertyTemplateEntity> ppetList = productPropertyTemplateDao.listProductPropertyTemplatePropertyForSort(param);
				
		if(ppetList != null && ppetList.size() == 1){
			// 如果返回1条记录，说明是最后一条（无法下移），或第一条（无法上移）,无需修改顺序
			return 1;
		}
		// 如果找到两条记录，说明是已经找到相邻的两条记录，交换顺序号即可
		if(ppetList != null && ppetList.size()>0){
			ProductPropertyTemplateEntity firstEntity = ppetList.get(0);
			ProductPropertyTemplateEntity secondEntity = ppetList.get(1);
			if(ProductConstants.SORT_DIRECTION.TOP.getId().equals(direction)){
				// 置顶操作
				int tmpSortNo = firstEntity.getSortNo();
				secondEntity.setSortNo(tmpSortNo-1);
				int result = productPropertyTemplateDao.updateProductPropertyTemplatePropertySort(secondEntity);
				return result;
			}else{
				// 上移 或 下移
				int tmpSortNo = firstEntity.getSortNo();
				firstEntity.setSortNo(secondEntity.getSortNo());
				secondEntity.setSortNo(tmpSortNo);
				int firstResult = productPropertyTemplateDao.updateProductPropertyTemplatePropertySort(firstEntity);
				int secondResult = productPropertyTemplateDao.updateProductPropertyTemplatePropertySort(secondEntity);
				if((firstResult+secondResult)==2){
					return 1;
				}else{
					return 0;
				}
			}
		}
		return 1;
	}
	
}
